/*!
	\file Arbre.h
	\brief La spécification des classes de type Noeud

	Contient toutes les spécifications de classes nécessaires pour représenter l'arbre abstrait
	\author Arnaud MAILLET
	\date 03.01.2009
*/
#ifndef ARBRE_H_
#define ARBRE_H_

#include <vector>
#include <iostream>
#include <iomanip>
using namespace std;

#include "Symbole.h"

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class Noeud
	\brief La classe mère permettant de représenter toute sorte de Noeud

	Classe abstraite dont dériveront toutes les classes servant à représenter l'arbre abstrait.
	Les méthodes suivantes sont associées à un objet de type Noeud :
	\li getLigne
	\li getColonne
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class Noeud {
  public:
	/*! 
	\fn Noeud(int ligne, int colonne)
	\brief Constructeur de la classe Noeud.

	Ce constructeur construit un noeud.
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
        */
	Noeud(int ligne, int colonne);

	/*! 
	\fn inline unsigned int getLigne()
	\brief Retourne la ligne courante
	\return la valeur de la ligne courante
	*/
	unsigned int getLigne() { return ligne; }

	/*! 
	\fn inline unsigned int getColonne()
	\brief Retourne la colonne courante
	\return la valeur de la colonne courante
	*/
	unsigned int getColonne() { return colonne; }

	/*! 
	\fn virtual int getValeur() = 0 
	\brief Retourne la valeur du noeud
	Méthode pure (non implémentée)
	\return la valeur du noeud
	*/
	virtual int getValeur() = 0 ; // méthode pure (non implémentée) qui rend la classe abstraite
 
	/*!
	\fn void  afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	\param indentation - donne le nombre d'indentation à afficher
	*/
	virtual void afficher(unsigned short indentation=0) { cout << setw(4*indentation) << " "; }

	/*!
	\fn void afficherPhp() = 0
	\brief Permet d'afficher un noeud façon Php
	Méthode pure (non implémentée)
	*/
	virtual void afficherPhp() = 0;

	/*! 
	\fn int getValeurCase(int val) = 0
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	Méthode pure (non implémentée)
	\return la valeur du noeud
	*/
	virtual int getValeurCase(int val) = 0;

	/*!
	\fn virtual ~Noeud()
	\brief Destructeur virtuel de la classe Noeud

	Ce destructeur permet de détruire un objet Noeud.
	*/
	virtual ~Noeud() {}
private:
	/*!
	\var unsigned int ligne
	\brief Contient la ligne dans le fichier, du noeud courant
	*/
	unsigned int ligne;

	/*!
	\var unsigned int colonne
	\brief Contient la colonne dans le fichier, du noeud courant
	*/
	unsigned int colonne;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudSeqInst
	\brief La classe  permettant de représenter un noeud d'une séquence d'instruction

	Classe pour représenter un noeud "sequence d'instruction" qui a autant de fils que d'instructions dans la séquence.
	Les méthodes suivantes sont associées à un objet de type NoeudSeqInst :
	\li ajouterInstruction
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudSeqInst : public Noeud {
public:
	/*! 
	\fn NoeudSeqInst(int ligne, int colonne)
	\brief Constructeur de la classe NoeudSeqInst.

	Ce constructeur construit une séquence d'instruction vide
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
        */
	NoeudSeqInst(int ligne, int colonne);   // construit une séquence d'instruction vide

	/*!
	\fn ~NoeudSeqInst()
	\brief Destructeur de la classe NoeudSeqInst
	Ce destructeur permet de détruire un objet NoeudSeqInst.
	*/
	~NoeudSeqInst() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue chaque instruction de la séquence.
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche la séquence d'instructions
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void ajouteInstruction(Noeud* instruction)
	\brief Permet d'ajouter une instruction à la séquence
	 Ajoute une instruction à la séquence
	\param instruction - noeud d'une instruction à ajouter
	*/
	void ajouteInstruction(Noeud* instruction); 

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();

	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var vector<Noeud *> tabInst
	\brief Pour stocker les instructions de la séquence
	*/
	vector<Noeud *> tabInst;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudAffectation
	\brief La classe permettant de représenter un noeud "affectation"

	Composé de 2 fils : la variable et l'expression qu'on lui affecte.
	Les méthodes suivantes sont associées à un objet de type NoeudAffectation :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudAffectation : public Noeud {
public:
	/*! 
	\fn NoeudAffectation(int ligne, int colonne, Noeud* variable, Noeud* expression)
	\brief Constructeur de la classe NoeudAffectation.

	Ce constructeur construit une affectation
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param variable - la variable de l'affectation
	\param expression - expression affectant la variable
        */
	NoeudAffectation(int ligne, int colonne, Noeud* variable, Noeud* expression); // construit une affectation

	/*!
	\fn ~NoeudAffectation()
	\brief Destructeur de la classe NoeudAffectation
	Ce destructeur permet de détruire un objet NoeudAffectation.
	*/
	~NoeudAffectation() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue l'expression et affecte sa valeur à la variable
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche l'affectation
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }
private:
	/*!
	\var Noeud* variable
	\brief Pour stocker la variable qui va être affecté
	*/
	Noeud* variable;

	/*!
	\var Noeud* expression
	\brief Pour stocker l'expression à affecter à la variable
	*/
	Noeud* expression;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudOperateurBinaire
	\brief La classe pour représenter un noeud "opération arithmétique".

	Composé d'un opérateur et de 2 fils : l'opérande gauche et l'opérande droit
	Les méthodes suivantes sont associées à un objet de type NoeudOperateurBinaire :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudOperateurBinaire : public Noeud {
public:
	/*! 
	\fn NoeudOperateurBinaire(int ligne, int colonne, Symbole operateur, Noeud* operandeGauche, Noeud* operandeDroit)
	\brief Constructeur de la classe NoeudOperateurBinaire.

	Ce constructeur construit une opération binaire : operandeGauche operateur OperandeDroit
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param operateur - le symbole de l'opération binaire
	\param operandeGauche - l'opérande gauche de l'opération binaire
	\param operandeDroit - l'opérande droit de l'opération binaire
        */
	NoeudOperateurBinaire(int ligne, int colonne, Symbole operateur, Noeud* operandeGauche, Noeud* operandeDroit);

	/*!
	\fn ~NoeudOperateurBinaire()
	\brief Destructeur de la classe NoeudOperateurBinaire
	Ce destructeur permet de détruire un objet NoeudOperateurBinaire.
	*/
	~NoeudOperateurBinaire() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue l'opération entre l'opérande de gauche et l'opérande de droite
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche l'opérateur binaire
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var Symbole operateur
	\brief Contient l'opérateur de l'opération binaire
	*/
	Symbole operateur;

	/*!
	\var Noeud*  operandeGauche
	\brief Contient l'opérande gauche de l'opération binaire
	*/
	Noeud*  operandeGauche;

	/*!
	\var Noeud*  operandeDroit
	\brief Contient l'opérande droit de l'opération binaire
	*/
	Noeud*  operandeDroit;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudOperateurUnaire
	\brief La classe pour représenter un noeud "opération unaire".

	Composé d'un opérateur et de 1 fils : l'opérande
	Les méthodes suivantes sont associées à un objet de type NoeudOperateurUnaire :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudOperateurUnaire : public Noeud {
public:
	/*! 
	\fn NoeudOperateurUnaire(int ligne, int colonne, Symbole operateur, Noeud* operande)
	\brief Constructeur de la classe NoeudOperateurUnaire.

	Ce constructeur construit une opération unaire : operateur operande
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param operateur - le symbole de l'opération unaire
	\param operande - l'opérande unaire de l'opération unaire
        */
	NoeudOperateurUnaire(int ligne, int colonne, Symbole operateur, Noeud* operande);

	/*!
	\fn ~NoeudOperateurUnaire()
	\brief Destructeur de la classe NoeudOperateurUnaire
	Ce destructeur permet de détruire un objet NoeudOperateurUnaire.
	*/
	~NoeudOperateurUnaire() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue l'opération unaire
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche l'opération unaire
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var Symbole operateur
	\brief Contient le symbole de l'opération unaire
	*/
	Symbole operateur;

	/*!
	\var Noeud*  operande
	\brief Contient l'opérande de l'opération unaire
	*/
	Noeud*  operande;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudBoucle
	\brief La classe pour représenter une boucle.

	Composé du symbole de la boucle et de 2 fils : la condition et l'instruction
	Les méthodes suivantes sont associées à un objet de type NoeudBoucle :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudBoucle : public Noeud {
public:
	/*! 
	\fn NoeudBoucle(int ligne, int colonne, Symbole boucle, Noeud* condition, Noeud* instruction)
	\brief Constructeur de la classe NoeudBoucle.

	Ce constructeur construit une boucle
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param boucle - le symbole de la boucle
	\param condition - la condition de la boucle
	\param instruction - l'instruction de la boucle
        */
	NoeudBoucle(int ligne, int colonne, Symbole boucle, Noeud* condition, Noeud* instruction);

	/*!
	\fn ~NoeudBoucle()
	\brief Destructeur de la classe NoeudBoucle
	Ce destructeur permet de détruire un objet NoeudBoucle
	*/
	~NoeudBoucle() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue la boucle
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche la boucle
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }
private:

	/*!
	\var Symbole  boucle
	\brief Contient le symbole de la boucle
	*/
	Symbole boucle;

	/*!
	\var Noeud* condition
	\brief Contient la condition de la boucle
	*/
	Noeud* condition;

	/*!
	\var Noeud* instruction
	\brief Contient l'instruction de la boucle
	*/
	Noeud* instruction;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudPour
	\brief La classe pour représenter une boucle de type Pour.

	Composé de 4 fils : l'affection, la condition, l'incrémentation et de l'instruction.
	Les méthodes suivantes sont associées à un objet de type NoeudPour :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudPour : public Noeud {
public:
	
	/*! 
	\fn NoeudPour(int ligne, int colonne, Noeud* affectation, Noeud* condition, Noeud* incrementation, Noeud* instruction)
	\brief Constructeur de la classe NoeudPour.

	Ce constructeur construit une boucle de type Pour
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param affectation - l'affectation du Pour
	\param condition - la condition du Pour
	\param incrementation - l'incrementation du Pour
	\param instruction - l'instruction du Pour
        */
	NoeudPour(int ligne, int colonne, Noeud* affectation, Noeud* condition, Noeud* incrementation, Noeud* instruction);

	/*!
	\fn ~NoeudPour()
	\brief Destructeur de la classe NoeudPour
	Ce destructeur permet de détruire un objet NoeudPour
	*/
	~NoeudPour() {}
	
	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Pour
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Pour
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var Noeud* affectation
	\brief Contient l'affection du Pour
	*/
	Noeud*  affectation;

	/*!
	\var Noeud* condition
	\brief Contient la condition du Pour
	*/
	Noeud*  condition;

	/*!
	\var Noeud* incrementation
	\brief Contient l'incrementation du Pour
	*/
	Noeud*  incrementation;

	/*!
	\var Noeud* instruction
	\brief Contient l'instruction du Pour
	*/
	Noeud*  instruction;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudSi
	\brief La classe pour représenter un Si

	Composé de 3 fils : la condition, l'instruction et le noeud suivant
	Les méthodes suivantes sont associées à un objet de type NoeudSi :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudSi : public Noeud {
public:
	/*! 
	\fn NoeudSi(int ligne, int colonne, Noeud* condition, Noeud* instruction, Noeud* suivant, bool si)
	\brief Constructeur de la classe NoeudSi.

	Ce constructeur construit un Si
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param condition - la condition du Si
	\param instruction - l'instruction du Si
	\param suivant - le noeud suivant
	\param si - indique si le noeud est un Si ou un SinonSi
        */
	NoeudSi(int ligne, int colonne, Noeud* condition, Noeud* instruction, Noeud* suivant, bool si);

	/*!
	\fn ~NoeudSi()
	\brief Destructeur de la classe NoeudSi
	Ce destructeur permet de détruire un objet NoeudSi
	*/
	~NoeudSi() {}

   	 /*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Si
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Si
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }
private:
	/*!
	\var Noeud* condition
	\brief Contient la condition du Si
	*/
	Noeud* condition;

	/*!
	\var Noeud* instruction
	\brief Contient l'instruction du Si
	*/
	Noeud*  instruction;

	/*!
	\var Noeud* suivant
	\brief Contient le noeud suivant du Si
	*/
	Noeud*  suivant;

	/*!
	\var bool si
	\brief Indique si le noeud est un Si ou un SinonSi
	*/	
	bool si;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudLire
	\brief La classe pour représenter un Lire

	Composé de 1 fils : la variable qui accueillera la valeur lue
	Les méthodes suivantes sont associées à un objet de type NoeudLire :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudLire : public Noeud {
public:
	/*! 
	\fn NoeudLire(int ligne, int colonne, Noeud* var)
	\brief Constructeur de la classe NoeudLire.

	Ce constructeur construit un Lire
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param var - la variable qui accueillera la valeur lue
        */
	NoeudLire(int ligne, int colonne, Noeud* var);

	/*!
	\fn ~NoeudLire()
	\brief Destructeur de la classe NoeudLire
	Ce destructeur permet de détruire un objet NoeudLire
	*/
	~NoeudLire() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Lire
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Lire
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var Noeud* var
	\brief Contient la variable qui accueillera la valeur lue
	*/
	Noeud*  var;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudEcrire
	\brief La classe pour représenter un Ecrire

	Composé de 1 fils : la variable qui sera afficher à l'écran
	Les méthodes suivantes sont associées à un objet de type NoeudEcrire :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudEcrire: public Noeud {
  public:
	/*! 
	\fn NoeudEcrire(int ligne, int colonne, bool chaine, Noeud* var)
	\brief Constructeur de la classe NoeudEcrire.

	Ce constructeur construit un Ecrire
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param chaine - indique si on doit afficher une chaine ou une variable
	\param var - la variable qui sera afficher à l'écran
        */
	NoeudEcrire(int ligne, int colonne, bool chaine, Noeud* var);

	/*!
	\fn ~NoeudEcrire()
	\brief Destructeur de la classe NoeudEcrire
	Ce destructeur permet de détruire un objet NoeudEcrire
	*/
	~NoeudEcrire() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Ecrire
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Ecrire
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }

private:
	/*!
	\var Noeud* var
	\brief Contient la variable qui accueillera la valeur lue
	*/
	Noeud*  var;

	/*!
	\var bool chaine
	\brief Indique si on doit afficher une chaine ou une variable
	*/
	bool chaine;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudChoisir
	\brief La classe pour représenter un Choisir

	Composé de 4 fils : le choisir, le cas, l'instruction et le noeud suivant
	Les méthodes suivantes sont associées à un objet de type NoeudChoisir :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudChoisir: public Noeud {
public:
	/*! 
	\fn NoeudChoisir(int ligne, int colonne, Noeud* choisir, Noeud* cas, Noeud* instruction, Noeud* suivant)
	\brief Constructeur de la classe NoeudChoisir.

	Ce constructeur construit un Choisir
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param choisir - la variable du choisir
	\param cas - le cas à évaluer avec la variable du choisir
	\param instruction - l'instruction du cas
	\param suivant - le noeud suivant
        */
	NoeudChoisir(int ligne, int colonne, Noeud* choisir, Noeud* cas, Noeud* instruction, Noeud* suivant);

	/*!
	\fn ~NoeudChoisir()
	\brief Destructeur de la classe NoeudChoisir
	Ce destructeur permet de détruire un objet NoeudChoisir
	*/
	~NoeudChoisir() {}

	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Choisir
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Choisir
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val) { return val; }
  private:
	/*!
	\var Noeud* choisir
	\brief Contient la variable du choisir
	*/
	Noeud* choisir;

	/*!
	\var Noeud* cas
	\brief Contient le cas à évaluer avec la variable du choisir
	*/
	Noeud* cas;

	/*!
	\var Noeud* instruction
	\brief Contient l'instruction du cas
	*/
	Noeud* instruction;

	/*!
	\var Noeud* suivant
	\brief Contient le noeud suivant
	*/
	Noeud* suivant;
};

////////////////////////////////////////////////////////////////////////////////
/*! 
	\class NoeudCas
	\brief La classe pour représenter un Cas

	Composé de 3 fils : le cas, l'instruction et le noeud suivant
	Les méthodes suivantes sont associées à un objet de type NoeudCas :
	\li getValeur
	\li afficher
	\li afficherPhp
	\li getValeurCase
*/
class NoeudCas: public Noeud {
public:
	/*! 
	\fn NoeudCas(int ligne, int colonne, Noeud* cas, Noeud* instruction, Noeud* suivant)
	\brief Constructeur de la classe NoeudCas.

	Ce constructeur construit un Cas
	\param ligne - la ligne du noeud
	\param colonne - la colonne du noeud
	\param cas - le cas à évaluer avec la variable du choisir
	\param instruction - l'instruction du cas
	\param suivant - le noeud suivant
        */
	NoeudCas(int ligne, int colonne, Noeud* cas, Noeud* instruction, Noeud* suivant);

	/*!
	\fn ~NoeudCas()
	\brief Destructeur de la classe NoeudCas
	Ce destructeur permet de détruire un objet NoeudCas
	*/
	~NoeudCas() {}

   	/*! 
	\fn int getValeur()
	\brief Retourne la valeur du noeud
	Evalue le Cas
	\return la valeur du noeud
	*/
	int getValeur();

	/*!
	\fn void afficher (unsigned short indentation=0)
	\brief Permet d'afficher un noeud avec un décalage (indentation) proportionnel à son niveau dans l'arbre
	Affiche le Cas
	\param indentation - donne le nombre d'indentation à afficher
	*/
	void afficher(unsigned short indentation=0);

	/*!
	\fn void afficherPhp()
	\brief Permet d'afficher un noeud façon Php
	*/
	void afficherPhp();
	
	/*! 
	\fn int getValeurCase(int val)
	\brief Permet de recuperer la valeur du noeud tout en donnant un paramètre
	\param val - valeur à donner en parametre, utile pour l'instruction 'choisir'
	\return la valeur du noeud
	*/
	int getValeurCase(int val);
private:
	/*!
	\var Noeud* cas
	\brief Contient le cas à évaluer avec la variable du choisir
	*/
	Noeud* cas;

	/*!
	\var Noeud* instruction
	\brief Contient l'instruction du cas
	*/
	Noeud* instruction;

	/*!
	\var Noeud* suivant
	\brief Contient le noeud suivant
	*/
	Noeud* suivant;
};
#endif /* ARBRE_H_ */
